package top.hudk.tank.utils;

import top.hudk.tank.config.GameConfig;
import top.hudk.tank.constant.GameConstant;
import top.hudk.tank.factory.Tank;
import top.hudk.tank.model.GameObject;

import java.awt.*;
import java.util.List;

/**
 * 作者：hudk
 * 时间：2021/9/12 12:48
 * 描述：
 */
public class FrameUtils {


    public static Rectangle badTankHome = new Rectangle((GameConfig.GAME_WIDTH + GameConstant.TANK_SIZE) / 2,
            GameConstant.TANK_SIZE,GameConstant.TANK_SIZE,GameConstant.TANK_SIZE);


    /**
     * 指定界面刷新的帧数
     *
     * @param frame       要刷新的窗口对象
     * @param frameNumber 帧数
     */
    public static void repaintByFrameNumber(Frame frame, int frameNumber) {
        int MillisecondsPerSecond = 1000;
        int intervalTime = MillisecondsPerSecond / frameNumber;
        repaintByTimeInterval(frame, intervalTime);
    }


    /**
     * 每间隔指定的时间就重画一次界面
     *
     * @param frame        要刷新的窗口对象
     * @param intervalTime 刷新间隔时间，毫秒值
     */
    public static void repaintByTimeInterval(Frame frame, int intervalTime) {
        //起始毫秒
        long beginTime = System.currentTimeMillis();
        //当前毫秒
        long currentTime;

        while (true) {
            //当前毫秒
            currentTime = System.currentTimeMillis();
            //计算【当前毫秒】距【起始毫秒】的时间间隔
            long timeInterval = currentTime - beginTime;
            //当时间间隔大于指定的间隔时间时，执行一次刷新界面
            if (timeInterval >= intervalTime) {
                //执行一次界面重画
                frame.repaint();
                //刷新后，起始毫秒值步进 intervalTime 毫秒
                beginTime += intervalTime;
            }
        }
    }


    /**
     * 界面中允许同时存在的最大坦克数量
     *
     * @return 允许的最大坦克数量
     */
    public static int allowMaxTankNumb() {
        //横向网格数量
        int horizontallyGridNumber = GameConfig.GAME_WIDTH / (GameConstant.TANK_SIZE + 10);
        //纵向网格数量
        int verticallyGridNumber = GameConfig.GAME_HEIGHT / (GameConstant.TANK_SIZE + 10);
        return horizontallyGridNumber * verticallyGridNumber / 2;
    }
//
//    public static void changeAllowCover(List<GameObject> objects){
//        boolean anyIsCover = false;
//        for (int i = 0; i < objects.size(); i++) {
//            if(! (objects.get(i) instanceof Tank)){
//                continue;
//            }
//            if(!((Tank)objects.get(i)).isAllowCover()){
//                continue;
//            }
//            boolean isCover = false;
//            for (int j = i + 1; j < objects.size(); j++) {
//                Object o1 = objects.get(i);
//                Object o2 = objects.get(j);
//                if (o2 instanceof Tank) {
//                    Tank tank1 = (Tank) o1;
//                    Tank tank2 = (Tank) o2;
//                    if (tank1.getRect().intersects(tank2.getRect())) {
//                        isCover = true;
//                        break;
//                    }
//                    isCover = false;
//                }
//            }
//            if(!isCover){
//                //已经没有相互覆盖
//                ((Tank)objects.get(i)).setAllowCover(false);
//            }
//        }
//    }


    public static void badTanksWaitForGoOneByOne(List<Tank> tanks, List<GameObject> objects) {
        if (tanks == null || tanks.size() == 0) {
            return;
        }
        Tank tank = tanks.get(0);
        tank.setAllowCover(true);
        tank.setGo(true);
        boolean isCover = false;
        for (int j = 0; j < objects.size(); j++) {
            Object o2 = objects.get(j);
            if (o2 instanceof Tank && !o2.equals(tank)) {
                Tank otherTank = (Tank) o2;
                if (tank.getRect().intersects(otherTank.getRect())) {
                    isCover = true;
                    break;
                }
            }
        }
        if (!isCover) {
            //已经没有相互覆盖
            tank.setAllowCover(false);
            tanks.remove(tank);
        }
    }

}
